{
 "nbformat": 4,
 "nbformat_minor": 0,
 "metadata": {
  "colab": {
   "name": "PI_DeepONet_DR.ipynb",
   "provenance": [],
   "collapsed_sections": []
  },
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  },
  "language_info": {
   "name": "python"
  },
  "accelerator": "GPU"
 },
 "cells": [
  {
   "cell_type": "code",
   "metadata": {
    "id": "nY1RmvevXrp9"
   },
   "source": [
    "import jax\n",
    "import jax.numpy as np\n",
    "from jax import random, grad, vmap, jit, hessian, lax\n",
    "from jax.example_libraries import optimizers\n",
    "from jax.nn import relu\n",
    "from jax.config import config\n",
    "from jax.ops import index_update, index\n",
    "from jax.flatten_util import ravel_pytree\n",
    "\n",
    "import itertools\n",
    "from functools import partial\n",
    "from torch.utils import data\n",
    "from tqdm import trange, tqdm\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "from scipy.interpolate import griddata\n",
    "%matplotlib inline"
   ],
   "execution_count": 1,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ikWFHV5IX5lh"
   },
   "source": [
    "# Data generator\n",
    "class DataGenerator(data.Dataset):\n",
    "    def __init__(self, u, y, s, \n",
    "                 batch_size=64, rng_key=random.PRNGKey(1234)):\n",
    "        'Initialization'\n",
    "        self.u = u # input sample\n",
    "        self.y = y # location\n",
    "        self.s = s # labeled data evulated at y (solution measurements, BC/IC conditions, etc.)\n",
    "        \n",
    "        self.N = u.shape[0]\n",
    "        self.batch_size = batch_size\n",
    "        self.key = rng_key\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        'Generate one batch of data'\n",
    "        self.key, subkey = random.split(self.key)\n",
    "        inputs, outputs = self.__data_generation(subkey)\n",
    "        return inputs, outputs\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def __data_generation(self, key):\n",
    "        'Generates data containing batch_size samples'\n",
    "        idx = random.choice(key, self.N, (self.batch_size,), replace=False)\n",
    "        s = self.s[idx,:]\n",
    "        y = self.y[idx,:]\n",
    "        u = self.u[idx,:]\n",
    "        # Construct batch\n",
    "        inputs = (u, y)\n",
    "        outputs = s\n",
    "        return inputs, outputs"
   ],
   "execution_count": 2,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "R4tCyvLs7luG"
   },
   "source": [
    "# Define the neural net\n",
    "def MLP(layers, activation=relu):\n",
    "  ''' Vanilla MLP'''\n",
    "  def init(rng_key):\n",
    "      def init_layer(key, d_in, d_out):\n",
    "          k1, k2 = random.split(key)\n",
    "          glorot_stddev = 1. / np.sqrt((d_in + d_out) / 2.)\n",
    "          W = glorot_stddev * random.normal(k1, (d_in, d_out))\n",
    "          b = np.zeros(d_out)\n",
    "          return W, b\n",
    "      key, *keys = random.split(rng_key, len(layers))\n",
    "      params = list(map(init_layer, keys, layers[:-1], layers[1:]))\n",
    "      return params\n",
    "  def apply(params, inputs):\n",
    "      for W, b in params[:-1]:\n",
    "          outputs = np.dot(inputs, W) + b\n",
    "          inputs = activation(outputs)\n",
    "      W, b = params[-1]\n",
    "      outputs = np.dot(inputs, W) + b\n",
    "      return outputs\n",
    "  return init, apply"
   ],
   "execution_count": 3,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "4ckGVVDAYCB7"
   },
   "source": [
    "# Define the model\n",
    "class PI_DeepONet:\n",
    "    def __init__(self, branch_layers, trunk_layers):    \n",
    "        # Network initialization and evaluation functions\n",
    "        self.branch_init, self.branch_apply = MLP(branch_layers, activation=np.tanh)\n",
    "        self.trunk_init, self.trunk_apply = MLP(trunk_layers, activation=np.tanh)\n",
    "\n",
    "        # Initialize\n",
    "        branch_params = self.branch_init(rng_key = random.PRNGKey(1234))\n",
    "        trunk_params = self.trunk_init(rng_key = random.PRNGKey(4321))\n",
    "        params = (branch_params, trunk_params)\n",
    "\n",
    "        # Use optimizers to set optimizer initialization and update functions\n",
    "        self.opt_init, \\\n",
    "        self.opt_update, \\\n",
    "        self.get_params = optimizers.adam(optimizers.exponential_decay(1e-3, \n",
    "                                                                      decay_steps=2000, \n",
    "                                                                      decay_rate=0.9))\n",
    "        self.opt_state = self.opt_init(params)\n",
    "\n",
    "        # Used to restore the trained model parameters\n",
    "        _, self.unravel_params = ravel_pytree(params)\n",
    "\n",
    "        self.itercount = itertools.count()\n",
    "\n",
    "        # Loggers\n",
    "        self.loss_log = []\n",
    "        self.loss_bcs_log = []\n",
    "        self.loss_res_log = []\n",
    "\n",
    "    # Define DeepONet architecture\n",
    "    def operator_net(self, params, u, x, t):\n",
    "        branch_params, trunk_params = params\n",
    "        y = np.stack([x, t])\n",
    "        B = self.branch_apply(branch_params, u)\n",
    "        T = self.trunk_apply(trunk_params, y)\n",
    "        outputs = np.sum(B * T)\n",
    "        return  outputs\n",
    "  \n",
    "    # Define ODE/PDE residual\n",
    "    def residual_net(self, params, u, x, t):\n",
    "        s = self.operator_net(params, u, x, t)\n",
    "        s_t = grad(self.operator_net, argnums=3)(params, u, x, t)\n",
    "        s_x = grad(self.operator_net, argnums=2)(params, u, x, t)\n",
    "        s_xx= grad(grad(self.operator_net, argnums=2), argnums=2)(params, u, x, t)\n",
    "\n",
    "        res = s_t - 0.01 * s_xx - 0.01 * s**2 \n",
    "        return res\n",
    "\n",
    "    # Define boundary loss\n",
    "    def loss_bcs(self, params, batch):\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "\n",
    "        # Compute forward pass\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, u, y[:,0], y[:,1])\n",
    "\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - s_pred)**2)\n",
    "        return loss\n",
    "\n",
    "    # Define residual loss\n",
    "    def loss_res(self, params, batch):\n",
    "        # Fetch data\n",
    "        # inputs: (u1, y), shape = (Nxm, m), (Nxm,1)\n",
    "        # outputs: u2, shape = (Nxm, 1)\n",
    "        inputs, outputs = batch\n",
    "        u, y = inputs\n",
    "        # Compute forward pass\n",
    "        pred = vmap(self.residual_net, (None, 0, 0, 0))(params, u, y[:,0], y[:,1])\n",
    "\n",
    "        # Compute loss\n",
    "        loss = np.mean((outputs.flatten() - pred)**2)\n",
    "        return loss   \n",
    "\n",
    "    # Define total loss\n",
    "    def loss(self, params, bcs_batch, res_batch):\n",
    "        loss_bcs = self.loss_bcs(params, bcs_batch)\n",
    "        loss_res = self.loss_res(params, res_batch)\n",
    "        loss = loss_bcs + loss_res\n",
    "        return loss \n",
    "\n",
    "    # Define a compiled update step\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def step(self, i, opt_state, bcs_batch, res_batch):\n",
    "        params = self.get_params(opt_state)\n",
    "        g = grad(self.loss)(params, bcs_batch, res_batch)\n",
    "        return self.opt_update(i, g, opt_state)\n",
    "\n",
    "    # Optimize parameters in a loop\n",
    "    def train(self, bcs_dataset, res_dataset, nIter = 10000):\n",
    "        # Define data iterators\n",
    "        bcs_data = iter(bcs_dataset)\n",
    "        res_data = iter(res_dataset)\n",
    "\n",
    "        pbar = trange(nIter)\n",
    "        # Main training loop\n",
    "        for it in pbar:\n",
    "            # Fetch data\n",
    "            bcs_batch= next(bcs_data)\n",
    "            res_batch = next(res_data)\n",
    "\n",
    "            self.opt_state = self.step(next(self.itercount), self.opt_state, bcs_batch, res_batch)\n",
    "            \n",
    "            if it % 100 == 0:\n",
    "                params = self.get_params(self.opt_state)\n",
    "\n",
    "                # Compute losses\n",
    "                loss_value = self.loss(params, bcs_batch, res_batch)\n",
    "                loss_bcs_value = self.loss_bcs(params, bcs_batch)\n",
    "                loss_res_value = self.loss_res(params, res_batch)\n",
    "\n",
    "                # Store losses\n",
    "                self.loss_log.append(loss_value)\n",
    "                self.loss_bcs_log.append(loss_bcs_value)\n",
    "                self.loss_res_log.append(loss_res_value)\n",
    "\n",
    "                # Print losses\n",
    "                pbar.set_postfix({'Loss': loss_value, \n",
    "                                  'loss_bcs' : loss_bcs_value, \n",
    "                                  'loss_physics': loss_res_value})\n",
    "           \n",
    "    # Evaluates predictions at test points  \n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_s(self, params, U_star, Y_star):\n",
    "        s_pred = vmap(self.operator_net, (None, 0, 0, 0))(params, U_star, Y_star[:,0], Y_star[:,1])\n",
    "        return s_pred\n",
    "\n",
    "    @partial(jit, static_argnums=(0,))\n",
    "    def predict_res(self, params, U_star, Y_star):\n",
    "        r_pred = vmap(self.residual_net, (None, 0, 0, 0))(params, U_star, Y_star[:,0], Y_star[:,1])\n",
    "        return r_pred"
   ],
   "execution_count": 4,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "EyGqzSnIv211"
   },
   "source": [
    "# Use double precision to generate data (due to GP sampling)\n",
    "def RBF(x1, x2, params):\n",
    "    output_scale, lengthscales = params\n",
    "    diffs = np.expand_dims(x1 / lengthscales, 1) - \\\n",
    "            np.expand_dims(x2 / lengthscales, 0)\n",
    "    r2 = np.sum(diffs**2, axis=2)\n",
    "    return output_scale * np.exp(-0.5 * r2)\n",
    "\n",
    "# A diffusion-reaction numerical solver\n",
    "def solve_ADR(key, Nx, Nt, P, length_scale):\n",
    "    \"\"\"Solve 1D\n",
    "    u_t = (k(x) u_x)_x - v(x) u_x + g(u) + f(x)\n",
    "    with zero initial and boundary conditions.\n",
    "    \"\"\"\n",
    "    xmin, xmax = 0, 1\n",
    "    tmin, tmax = 0, 1\n",
    "    k = lambda x: 0.01*np.ones_like(x)\n",
    "    v = lambda x: np.zeros_like(x)\n",
    "    g = lambda u: 0.01*u ** 2\n",
    "    dg = lambda u: 0.02 * u\n",
    "    u0 = lambda x: np.zeros_like(x)\n",
    "\n",
    "    # Generate subkeys\n",
    "    subkeys = random.split(key, 2)\n",
    "\n",
    "    # Generate a GP sample\n",
    "    N = 512\n",
    "    gp_params = (1.0, length_scale)\n",
    "    jitter = 1e-10\n",
    "    X = np.linspace(xmin, xmax, N)[:,None]\n",
    "    K = RBF(X, X, gp_params)\n",
    "    L = np.linalg.cholesky(K + jitter*np.eye(N))\n",
    "    gp_sample = np.dot(L, random.normal(subkeys[0], (N,)))\n",
    "    # Create a callable interpolation function  \n",
    "    f_fn = lambda x: np.interp(x, X.flatten(), gp_sample)\n",
    "\n",
    "    # Create grid\n",
    "    x = np.linspace(xmin, xmax, Nx)\n",
    "    t = np.linspace(tmin, tmax, Nt)\n",
    "    h = x[1] - x[0]\n",
    "    dt = t[1] - t[0]\n",
    "    h2 = h ** 2\n",
    "\n",
    "    # Compute coefficients and forcing\n",
    "    k = k(x)\n",
    "    v = v(x)\n",
    "    f = f_fn(x)\n",
    "\n",
    "    # Compute finite difference operators\n",
    "    D1 = np.eye(Nx, k=1) - np.eye(Nx, k=-1)\n",
    "    D2 = -2 * np.eye(Nx) + np.eye(Nx, k=-1) + np.eye(Nx, k=1)\n",
    "    D3 = np.eye(Nx - 2)\n",
    "    M = -np.diag(D1 @ k) @ D1 - 4 * np.diag(k) @ D2\n",
    "    m_bond = 8 * h2 / dt * D3 + M[1:-1, 1:-1]\n",
    "    v_bond = 2 * h * np.diag(v[1:-1]) @ D1[1:-1, 1:-1] + 2 * h * np.diag(\n",
    "        v[2:] - v[: Nx - 2]\n",
    "    )\n",
    "    mv_bond = m_bond + v_bond\n",
    "    c = 8 * h2 / dt * D3 - M[1:-1, 1:-1] - v_bond\n",
    "\n",
    "    # Initialize solution and apply initial condition\n",
    "    u = np.zeros((Nx, Nt))\n",
    "    u = index_update(u, index[:,0], u0(x))\n",
    "    # Time-stepping update\n",
    "    def body_fn(i, u):\n",
    "        gi = g(u[1:-1, i])\n",
    "        dgi = dg(u[1:-1, i])\n",
    "        h2dgi = np.diag(4 * h2 * dgi)\n",
    "        A = mv_bond - h2dgi\n",
    "        b1 = 8 * h2 * (0.5 * f[1:-1] + 0.5 * f[1:-1] + gi)\n",
    "        b2 = (c - h2dgi) @ u[1:-1, i].T\n",
    "        u = index_update(u, index[1:-1, i + 1], np.linalg.solve(A, b1 + b2))\n",
    "        return u\n",
    "    # Run loop\n",
    "    UU = lax.fori_loop(0, Nt-1, body_fn, u)\n",
    "\n",
    "    # Input sensor locations and measurements\n",
    "    xx = np.linspace(xmin, xmax, m)\n",
    "    u = f_fn(xx)\n",
    "    # Output sensor locations and measurements\n",
    "    idx = random.randint(subkeys[1], (P,2), 0, max(Nx,Nt))\n",
    "    y = np.concatenate([x[idx[:,0]][:,None], t[idx[:,1]][:,None]], axis = 1)\n",
    "    s = UU[idx[:,0], idx[:,1]]\n",
    "    # x, t: sampled points on grid\n",
    "    return (x, t, UU), (u, y, s)\n",
    "\n",
    "# Geneate training data corresponding to one input sample\n",
    "def generate_one_training_data(key, P, Q):\n",
    "    # Numerical solution\n",
    "    (x, t, UU), (u, y, s) = solve_ADR(key, Nx , Nt, P, length_scale)\n",
    "\n",
    "    # Geneate subkeys\n",
    "    subkeys = random.split(key, 4)\n",
    "\n",
    "    # Sample points from the boundary and the inital conditions\n",
    "    # Here we regard the initial condition as a special type of boundary conditions\n",
    "    x_bc1 = np.zeros((P // 3, 1))\n",
    "    x_bc2 = np.ones((P // 3, 1))\n",
    "    x_bc3 = random.uniform(key = subkeys[0], shape = (P // 3, 1))\n",
    "    x_bcs = np.vstack((x_bc1, x_bc2, x_bc3))\n",
    "\n",
    "    t_bc1 = random.uniform(key = subkeys[1], shape = (P//3 * 2, 1))\n",
    "    t_bc2 = np.zeros((P//3, 1))\n",
    "    t_bcs = np.vstack([t_bc1, t_bc2])\n",
    "\n",
    "    # Training data for BC and IC\n",
    "    u_train = np.tile(u, (P,1))\n",
    "    y_train = np.hstack([x_bcs, t_bcs])\n",
    "    s_train = np.zeros((P, 1))\n",
    "\n",
    "    # Sample collocation points\n",
    "    x_r_idx= random.choice(subkeys[2], np.arange(Nx), shape = (Q,1))\n",
    "    x_r = x[x_r_idx]\n",
    "    t_r = random.uniform(subkeys[3], minval = 0, maxval = 1, shape = (Q,1))\n",
    "\n",
    "    # Training data for the PDE residual\n",
    "    u_r_train = np.tile(u, (Q,1))\n",
    "    y_r_train = np.hstack([x_r, t_r])\n",
    "    s_r_train = u[x_r_idx]\n",
    "\n",
    "    return u_train, y_train, s_train, u_r_train, y_r_train, s_r_train\n",
    "\n",
    "# Geneate test data corresponding to one input sample\n",
    "def generate_one_test_data(key, P):\n",
    "    Nx = P\n",
    "    Nt = P\n",
    "    (x, t, UU), (u, y, s) = solve_ADR(key, Nx , Nt, P, length_scale)\n",
    "\n",
    "    XX, TT = np.meshgrid(x, t)\n",
    "\n",
    "    u_test = np.tile(u, (P**2,1))\n",
    "    y_test = np.hstack([XX.flatten()[:,None], TT.flatten()[:,None]])\n",
    "    s_test = UU.T.flatten()\n",
    "\n",
    "    return u_test, y_test, s_test\n",
    "\n",
    "# Geneate training data corresponding to N input sample\n",
    "def generate_training_data(key, N, P, Q):\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "    u_train, y_train, s_train, u_r_train, y_r_train, s_r_train = vmap(generate_one_training_data, (0, None, None))(keys, P, Q)\n",
    "\n",
    "    u_train = np.float32(u_train.reshape(N * P,-1))\n",
    "    y_train = np.float32(y_train.reshape(N * P,-1))\n",
    "    s_train = np.float32(s_train.reshape(N * P,-1))\n",
    "\n",
    "    u_r_train = np.float32(u_r_train.reshape(N * Q,-1))\n",
    "    y_r_train = np.float32(y_r_train.reshape(N * Q,-1))\n",
    "    s_r_train = np.float32(s_r_train.reshape(N * Q,-1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u_train, y_train, s_train, u_r_train, y_r_train,  s_r_train\n",
    "\n",
    "# Geneate test data corresponding to N input sample\n",
    "def generate_test_data(key, N, P):\n",
    "\n",
    "    config.update(\"jax_enable_x64\", True)\n",
    "    keys = random.split(key, N)\n",
    "\n",
    "    u_test, y_test, s_test = vmap(generate_one_test_data, (0, None))(keys, P)\n",
    "\n",
    "    u_test = np.float32(u_test.reshape(N * P**2,-1))\n",
    "    y_test = np.float32(y_test.reshape(N * P**2,-1))\n",
    "    s_test = np.float32(s_test.reshape(N * P**2,-1))\n",
    "\n",
    "    config.update(\"jax_enable_x64\", False)\n",
    "    return u_test, y_test, s_test\n",
    "\n",
    "# Compute relative l2 error over N test samples.\n",
    "def compute_error(key, P):\n",
    "    # Generate one test sample\n",
    "    u_test, y_test, s_test = generate_test_data(key, 1, P)\n",
    "    # Predict  \n",
    "    s_pred = model.predict_s(params, u_test, y_test)[:,None]\n",
    "    # Compute relative l2 error\n",
    "    error_s = np.linalg.norm(s_test - s_pred) / np.linalg.norm(s_test) \n",
    "    return error_s"
   ],
   "execution_count": 5,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "s4o8uU971yfJ"
   },
   "source": [
    "key = random.PRNGKey(0)\n",
    "\n",
    "# GRF length scale\n",
    "length_scale = 0.2\n",
    "\n",
    "# Resolution of the solution\n",
    "Nx = 100\n",
    "Nt = 100\n",
    "\n",
    "N = 5000 # number of input samples\n",
    "m = Nx   # number of input sensors\n",
    "P_train = 300 # number of output sensors, 100 for each side \n",
    "Q_train = 100  # number of collocation points for each input sample\n",
    "\n",
    "u_bcs_train, y_bcs_train, s_bcs_train, u_res_train, y_res_train, s_res_train = generate_training_data(key, N, P_train, Q_train)"
   ],
   "execution_count": 6,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "ZdbEC_IV5d8r"
   },
   "source": [
    "# Initialize model\n",
    "branch_layers = [m, 50, 50, 50, 50, 50]\n",
    "trunk_layers =  [2, 50, 50, 50, 50, 50]\n",
    "model = PI_DeepONet(branch_layers, trunk_layers)"
   ],
   "execution_count": 7,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "FDVeE-dk6I35"
   },
   "source": [
    "# Create data set\n",
    "batch_size = 10000\n",
    "bcs_dataset = DataGenerator(u_bcs_train, y_bcs_train, s_bcs_train, batch_size)\n",
    "res_dataset = DataGenerator(u_res_train, y_res_train, s_res_train, batch_size)"
   ],
   "execution_count": 8,
   "outputs": []
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "RYb9vB0h7Kzl",
    "outputId": "8238b9a7-0090-4aaa-c52e-39ff0f0f9ded"
   },
   "source": [
    "# Train\n",
    "model.train(bcs_dataset, res_dataset, nIter=120000)\n"
   ],
   "execution_count": 9,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "100%|██████████| 120000/120000 [50:07<00:00, 39.90it/s, Loss=6.156332e-05, loss_bcs=1.8703351e-05, loss_physics=4.2859963e-05]\n"
     ],
     "name": "stderr"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "cN2my_9hfe4e",
    "outputId": "5af180ff-6dc0-4fc6-eca8-c8bb7f07f477"
   },
   "source": [
    "# Test data\n",
    "N_test = 100 # number of input samples \n",
    "P_test = m   # number of sensors \n",
    "key_test = random.PRNGKey(1234567)\n",
    "keys_test = random.split(key_test, N_test)\n",
    "\n",
    "# Predict\n",
    "params = model.get_params(model.opt_state)\n",
    "\n",
    "# Compute error\n",
    "error_s = vmap(compute_error, (0, None))(keys_test,P_test) \n",
    "\n",
    "print('mean of relative L2 error of s: {:.2e}'.format(error_s.mean()))\n",
    "print('std of relative L2 error of s: {:.2e}'.format(error_s.std()))"
   ],
   "execution_count": 10,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "mean of relative L2 error of s: 5.33e-03\n",
      "std of relative L2 error of s: 3.05e-03\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 369
    },
    "id": "E1M0cRJzt2yK",
    "outputId": "7fc05c72-2285-44fc-ffa5-b858f7df8e08"
   },
   "source": [
    "#Plot for loss function\n",
    "plt.figure(figsize = (6,5))\n",
    "plt.plot(model.loss_bcs_log, lw=2, label='bcs')\n",
    "plt.plot(model.loss_res_log, lw=2, label='res')\n",
    "\n",
    "plt.xlabel('Iteration')\n",
    "plt.ylabel('Loss')\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 11,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "id": "865O-1F49oIm",
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "outputId": "2c8c7603-9d3c-49e1-d3fb-021c97da6522"
   },
   "source": [
    "# Generate one test sample\n",
    "key = random.PRNGKey(12345)\n",
    "P_test = 100\n",
    "Nx = m\n",
    "u_test, y_test, s_test = generate_test_data(key, 1, P_test)\n",
    "\n",
    "# Predict\n",
    "params = model.get_params(model.opt_state)\n",
    "s_pred = model.predict_s(params, u_test, y_test)\n",
    "\n",
    "# Generate an uniform mesh\n",
    "x = np.linspace(0, 1, Nx)\n",
    "t = np.linspace(0, 1, Nt)\n",
    "XX, TT = np.meshgrid(x, t)\n",
    "\n",
    "# Grid data\n",
    "S_pred = griddata(y_test, s_pred.flatten(), (XX,TT), method='cubic')\n",
    "S_test = griddata(y_test, s_test.flatten(), (XX,TT), method='cubic')\n",
    "\n",
    "# Compute the relative l2 error \n",
    "error = np.linalg.norm(S_pred - S_test, 2) / np.linalg.norm(S_test, 2) \n",
    "print('Relative l2 errpr: {:.3e}'.format(error))"
   ],
   "execution_count": 12,
   "outputs": [
    {
     "output_type": "stream",
     "text": [
      "Relative l2 errpr: 4.931e-03\n"
     ],
     "name": "stdout"
    }
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 369
    },
    "id": "662sBR7X-I9x",
    "outputId": "6dd6a87c-e4c7-4ede-eec5-85cc3e72cca2"
   },
   "source": [
    "# Plot\n",
    "fig = plt.figure(figsize=(18,5))\n",
    "plt.subplot(1,3,1)\n",
    "plt.pcolor(XX,TT, S_test, cmap='seismic')\n",
    "plt.colorbar()\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Exact $s(x,t)$')\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,3,2)\n",
    "plt.pcolor(XX,TT, S_pred, cmap='seismic')\n",
    "plt.colorbar()\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Predict $s(x,t)$')\n",
    "plt.tight_layout()\n",
    "\n",
    "plt.subplot(1,3,3)\n",
    "plt.pcolor(XX,TT, S_pred - S_test, cmap='seismic')\n",
    "plt.colorbar()\n",
    "plt.xlabel('$x$')\n",
    "plt.ylabel('$t$')\n",
    "plt.title('Absolute error')\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "execution_count": 13,
   "outputs": [
    {
     "output_type": "display_data",
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x360 with 6 Axes>"
      ]
     },
     "metadata": {
      "tags": [],
      "needs_background": "light"
     }
    }
   ]
  }
 ]
}
